{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RainbowDQN_CartPole-v1\n",
    "\n",
    "[Rainbow DQN](https://arxiv.org/pdf/1710.02298) 结合了DQN算法的6个扩展改进，其中包括DDQN，Dueling DQN，Prioritized Replay、Multi-step Learning、Distributional RL、Noisy Net，再加上基础的DQN，凑齐七种因素，召唤神龙Rainbow！具体如下：\n",
    "\n",
    "* 🎲 NoisyNet: 替代 ε-greedy，实现探索\n",
    "* 🧠 Dueling DQN: 分离 value 与 advantage\n",
    "* 📊 Categorical DQN: 用分布来逼近 Q 值\n",
    "* 🔁 Double DQN: 减少过估计\n",
    "* 🧪 PER (Prioritized Experience Replay): 优先采样\n",
    "* 🔄 N-step Learning: 多步回报"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义参数\n",
    "\n",
    "为方便实验调试，把所有参数都放在一起"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.algo_name = 'RainbowDQN' # 算法名称\n",
    "        self.env_id = 'CartPole-v1' # 环境id\n",
    "        self.mode = 'train'\n",
    "        self.seed = 1 # 随机种子，便于复现，0表示不设置\n",
    "        self.max_epsiode = 200 # 训练的回合数\n",
    "        self.max_step = 200 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        #region 在线测试相关参数\n",
    "        self.online_eval_episode = 10 # 测试的回合数\n",
    "        self.online_eval_freq = 2000 # 在线测试的频率, 模型每更新N次就测试一次\n",
    "        #endregion\n",
    "        self.gamma = 0.99 # 折扣因子\n",
    "        self.epsilon_start = 0.95 # e-greedy策略中初始epsilon\n",
    "        self.epsilon_end = 0.01 # e-greedy策略中的终止epsilon\n",
    "        self.epsilon_decay = 0.0004 # e-greedy策略中epsilon的衰减率\n",
    "        #region buffer相关参数\n",
    "        self.buffer_size = 100000 # 经验回放池的容量\n",
    "        self.buffer_n_step = 3 # n-step的步数\n",
    "        self.per_alpha = 0.6 # 优先级的指数 \n",
    "        self.per_epsilon = 1e-5 # 优先级的最小值\n",
    "        self.per_beta = 0.4 # beta的初始值\n",
    "        self.per_beta_increment_per_sampling = 0.0001 # beta的增量\n",
    "        self.hidden_dim = 256 # 神经网络的隐藏层维度\n",
    "        self.batch_size = 256 # 批次大小\n",
    "        self.target_update = 100 # 目标网络的更新频率\n",
    "        self.update_every = 50 # 每采样50步更新\n",
    "        self.lr = 0.0001 # 学习率\n",
    "        self.tau = 0.005 # 软更新参数\n",
    "        # 被称为C51的原因就是原子个数为51\n",
    "        self.n_atoms = 51 # 原子个数\n",
    "        self.v_min = -100 # 原子的最小值\n",
    "        self.v_max = 100 # 原子的最大值\n",
    "        self.device = 'cpu' if not torch.cuda.is_available() else 'cuda' # 使用cpu还是gpu\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "定义一个三层的全连接网络（FCN），也叫多层感知机（MLP）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "class NoisyLinear(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim, std_init=0.4):\n",
    "        super(NoisyLinear, self).__init__()\n",
    "        \n",
    "        self.input_dim  = input_dim\n",
    "        self.output_dim = output_dim\n",
    "        self.std_init     = std_init\n",
    "        \n",
    "        self.weight_mu    = nn.Parameter(torch.FloatTensor(output_dim, input_dim))\n",
    "        self.weight_sigma = nn.Parameter(torch.FloatTensor(output_dim, input_dim))\n",
    "        self.register_buffer('weight_epsilon', torch.FloatTensor(output_dim, input_dim))\n",
    "        \n",
    "        self.bias_mu    = nn.Parameter(torch.FloatTensor(output_dim))\n",
    "        self.bias_sigma = nn.Parameter(torch.FloatTensor(output_dim))\n",
    "        self.register_buffer('bias_epsilon', torch.FloatTensor(output_dim))\n",
    "        \n",
    "        self.reset_parameters()\n",
    "        self.reset_noise()\n",
    "    \n",
    "    def forward(self, x):\n",
    "        # 只有在训练的时候需要使用噪声探索，测试时使用均值即可\n",
    "        if self.training: \n",
    "            weight = self.weight_mu + self.weight_sigma.mul(self.weight_epsilon)\n",
    "            bias   = self.bias_mu   + self.bias_sigma.mul(self.bias_epsilon)\n",
    "        else:\n",
    "            weight = self.weight_mu\n",
    "            bias   = self.bias_mu\n",
    "        return F.linear(x, weight, bias)\n",
    "    \n",
    "    def reset_parameters(self):\n",
    "        mu_range = 1 / math.sqrt(self.weight_mu.size(1))\n",
    "        \n",
    "        self.weight_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.weight_sigma.data.fill_(self.std_init / math.sqrt(self.weight_sigma.size(1)))\n",
    "        \n",
    "        self.bias_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.bias_sigma.data.fill_(self.std_init / math.sqrt(self.bias_sigma.size(0)))\n",
    "    \n",
    "    def reset_noise(self):\n",
    "        epsilon_in  = self._scale_noise(self.input_dim)\n",
    "        epsilon_out = self._scale_noise(self.output_dim)\n",
    "        \n",
    "        self.weight_epsilon.copy_(epsilon_out.ger(epsilon_in))\n",
    "        self.bias_epsilon.copy_(self._scale_noise(self.output_dim))\n",
    "    \n",
    "    def _scale_noise(self, size):\n",
    "        x = torch.randn(size)\n",
    "        x = x.sign().mul(x.abs().sqrt())\n",
    "        return x\n",
    "\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, cfg: Config, state_dim, action_dim, hidden_dim=256):\n",
    "        \"\"\" 初始化q网络，为全连接网络\n",
    "        \"\"\"\n",
    "        super(Model, self).__init__()\n",
    "        self.n_atoms = cfg.n_atoms\n",
    "        self.action_dim = action_dim\n",
    "        self.feature = nn.Sequential(\n",
    "            nn.Linear(state_dim, hidden_dim),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        # 这里分成两部分，分别是advantage和value, 即Dueling DQN的结构\n",
    "        self.advantage = nn.Sequential(\n",
    "            NoisyLinear(hidden_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            NoisyLinear(hidden_dim, action_dim * self.n_atoms)\n",
    "        )\n",
    "\n",
    "        self.value = nn.Sequential(\n",
    "            NoisyLinear(hidden_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            NoisyLinear(hidden_dim, self.n_atoms)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.feature(x)\n",
    "        value = self.value(x).view(-1, 1, self.n_atoms) # (batch_size, 1, n_atoms)\n",
    "        advantage = self.advantage(x).view(-1, self.action_dim, self.n_atoms) # (batch_size, a_dim, n_atoms)\n",
    "        q_atoms = value + advantage - advantage.mean(dim=1, keepdim=True) # (batch_size, a_dim, n_atoms)\n",
    "        dist = torch.softmax(q_atoms, dim=-1)\n",
    "        # dist = torch.log_softmax(q_atoms, dim=-1)\n",
    "        return dist\n",
    "    \n",
    "    def reset_noise(self):\n",
    "        for module in self.modules():\n",
    "            if isinstance(module, NoisyLinear):\n",
    "                module.reset_noise()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义经验回放\n",
    "\n",
    "经验回放主要有两个功能，一是存储样本(push)，二是随时采样样本(sample)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from collections import deque\n",
    "\n",
    "class SumTree:\n",
    "    def __init__(self, capacity):\n",
    "        self.capacity = capacity\n",
    "        self.tree = np.zeros(2 * capacity - 1)\n",
    "        self.data = np.zeros(capacity, dtype=object)\n",
    "        self.data_pointer = 0\n",
    "\n",
    "    def add(self, priority, data):\n",
    "        tree_idx = self.data_pointer + self.capacity - 1\n",
    "        self.data[self.data_pointer] = data\n",
    "        self.update(tree_idx, priority)\n",
    "        self.data_pointer += 1\n",
    "        if self.data_pointer >= self.capacity:\n",
    "            self.data_pointer = 0\n",
    "\n",
    "    def update(self, tree_idx, priority):\n",
    "        change = priority - self.tree[tree_idx]\n",
    "        self.tree[tree_idx] = priority\n",
    "        while tree_idx != 0:\n",
    "            tree_idx = (tree_idx - 1) // 2\n",
    "            self.tree[tree_idx] += change\n",
    "\n",
    "    def get_leaf(self, v):\n",
    "        parent_idx = 0\n",
    "        while True:\n",
    "            left_child_idx = 2 * parent_idx + 1\n",
    "            right_child_idx = left_child_idx + 1\n",
    "            if left_child_idx >= len(self.tree):\n",
    "                leaf_idx = parent_idx\n",
    "                break\n",
    "            else:\n",
    "                if v <= self.tree[left_child_idx]:\n",
    "                    parent_idx = left_child_idx\n",
    "                else:\n",
    "                    v -= self.tree[left_child_idx]\n",
    "                    parent_idx = right_child_idx\n",
    "        data_idx = leaf_idx - self.capacity + 1\n",
    "        return leaf_idx, self.tree[leaf_idx], self.data[data_idx]\n",
    "    \n",
    "    @property\n",
    "    def max_priority(self):\n",
    "        return self.tree[-self.capacity:].max()\n",
    "        \n",
    "    @property\n",
    "    def total_priority(self):\n",
    "        return self.tree[0]\n",
    "\n",
    "class ReplayBuffer:\n",
    "    def __init__(self, cfg):\n",
    "        self.capacity = cfg.buffer_size\n",
    "        self.alpha = cfg.per_alpha\n",
    "        self.beta = cfg.per_beta\n",
    "        self.beta_increment_per_sampling = cfg.per_beta_increment_per_sampling\n",
    "        self.epsilon = cfg.per_epsilon\n",
    "        self.tree = SumTree(self.capacity)\n",
    "        self.n_step = cfg.buffer_n_step\n",
    "        self.gamma = cfg.gamma\n",
    "        self.n_step_buffer = deque(maxlen=cfg.buffer_n_step)\n",
    "        \n",
    "    def push(self, transition):\n",
    "        # max_prio = self.tree.tree[-self.tree.capacity:].max()\n",
    "        # transition = state, action, reward, next_state, done\n",
    "        self.n_step_buffer.append(transition)\n",
    "        if len(self.n_step_buffer) < self.n_step:\n",
    "            return\n",
    "        R, next_state, done = 0, self.n_step_buffer[-1][3], self.n_step_buffer[-1][4]\n",
    "        for i , (_, _, r, _, _) in enumerate(self.n_step_buffer):\n",
    "            R += (self.gamma ** i) * r\n",
    "        state, action = self.n_step_buffer[0][:2]\n",
    "        transition = (state, action, R, next_state, done)\n",
    "        max_prio = self.tree.max_priority\n",
    "        if max_prio == 0:\n",
    "            max_prio = 1.0\n",
    "        self.tree.add(max_prio, transition)\n",
    "\n",
    "    def sample(self, batch_size):\n",
    "        self.beta = min(1.0, self.beta + self.beta_increment_per_sampling)\n",
    "        minibatch = []\n",
    "        idxs = []\n",
    "        segment = self.tree.total_priority / batch_size\n",
    "        priorities = []\n",
    "\n",
    "        for i in range(batch_size):\n",
    "            a = segment * i\n",
    "            b = segment * (i + 1)\n",
    "            s = np.random.uniform(a, b)\n",
    "            idx, p, data = self.tree.get_leaf(s)\n",
    "            minibatch.append(data)\n",
    "            idxs.append(idx)\n",
    "            priorities.append(p)\n",
    "\n",
    "        sampling_probabilities = priorities / self.tree.total_priority\n",
    "        is_weight = np.power(self.tree.capacity * sampling_probabilities, -self.beta)\n",
    "        is_weight /= is_weight.max()\n",
    "\n",
    "        batch = list(zip(*minibatch))\n",
    "        return tuple(map(lambda x: np.array(x), batch)), idxs, is_weight\n",
    "\n",
    "    def update_priorities(self, idxs, priorities):\n",
    "        for idx, priority in zip(idxs, priorities):\n",
    "            self.tree.update(idx, (np.abs(priority) + self.epsilon) ** self.alpha)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.tree.data)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义策略\n",
    "\n",
    "\n",
    "智能体主要负责与环境交互并更新策略(模型参数)，因此首先需要定义sample_action和predict_action两个函数，前者用于训练时的采样动作，一般会采取$\\varepsilon-\\text{greedy}$策略来提高探索能力，后者一般用于测试算法时的预测动作。其次需要定义update函数，这个函数主要用来从经验回放中采样样本，然后更新模型参数。\n",
    "\n",
    "注意：\n",
    "* 每个张量的维度要对应上，否则可能会报错或者不收敛"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "\n",
    "class ExplorationMgr:\n",
    "    ''' 探索管理器\n",
    "    '''\n",
    "    def __init__(self, cfg: Config):\n",
    "\n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end = cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.epsilon = cfg.epsilon_start\n",
    "        self.update_cnt = 0\n",
    "\n",
    "    def update_epsilon(self):\n",
    "        ''' 更新并返回探索概率\n",
    "        '''\n",
    "        self.update_cnt += 1\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.update_cnt * self.epsilon_decay) \n",
    "        return self.epsilon\n",
    "\n",
    "class Policy:\n",
    "    def __init__(self, cfg: Config, state_dim:int, action_dim:int):\n",
    "        self.tau = cfg.tau # 软更新的参数\n",
    "        self.action_dim = action_dim # 动作空间的维度\n",
    "        self.gamma = cfg.gamma # 奖励的折扣因子\n",
    "        self.n_atoms = cfg.n_atoms # 离散化的原子数\n",
    "        self.v_min = cfg.v_min # 原子的最小值\n",
    "        self.v_max = cfg.v_max # 原子的最大值\n",
    "        self.batch_size = cfg.batch_size # 批量大小\n",
    "        self.device = torch.device(cfg.device) # CPU或GPU \n",
    "        # e-greedy策略相关参数\n",
    "        self.support = torch.linspace(self.v_min, self.v_max, steps = self.n_atoms, device=self.device)\n",
    "        self.proj_dist = torch.zeros((self.batch_size, self.n_atoms), device=self.device) # [B, n_atoms]\n",
    "        self.offset = torch.linspace(0, (self.batch_size - 1) * self.n_atoms, self.batch_size,device=self.device).unsqueeze(-1).long() # [B, 1]\n",
    "        self.delta_z = float(self.v_max - self.v_min) / (self.n_atoms - 1)\n",
    "        self.memory = ReplayBuffer(cfg)\n",
    "        self.exploration_mgr = ExplorationMgr(cfg) # 探索管理器\n",
    "        # 当前网络和目标网络\n",
    "        self.model = Model(cfg, state_dim, self.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        # print(self.model(torch.randn(1, cfg.state_dim)))\n",
    "        self.target_model = Model(cfg, state_dim, self.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        # 复制参数到目标网络\n",
    "        self.target_model.load_state_dict(self.model.state_dict())\n",
    "        # for target_param, param in zip(self.target_model.parameters(),self.model.parameters()): \n",
    "        #     target_param.data.copy_(param.data)\n",
    "        self.optimizer = optim.Adam(self.model.parameters(), lr=cfg.lr) # 优化器\n",
    "        self.update_cnt = 0 # 用于延迟更新目标网络的计数\n",
    "        \n",
    "    def sample_action(self, state):\n",
    "        ''' 采样动作\n",
    "        '''\n",
    "        if random.random() > self.exploration_mgr.update_epsilon(): # epsilon-greedy策略\n",
    "            action = self.predict_action(state)\n",
    "        else:\n",
    "            action = random.randrange(self.action_dim)\n",
    "        return action\n",
    "    \n",
    "    @torch.no_grad() # 不计算梯度，该装饰器效果等同于with torch.no_grad()：\n",
    "    def predict_action(self, state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0) # [1, state_dim]\n",
    "        dist = self.model(state)\n",
    "        q_values = (dist * self.support).sum(2)\n",
    "        action = torch.argmax(q_values).detach().cpu().numpy().item()\n",
    "        return action\n",
    "    \n",
    "    def get_policy_params(self):\n",
    "        ''' 获取当前策略的参数\n",
    "        '''\n",
    "        return self.model.state_dict()\n",
    "    \n",
    "    def set_policy_params(self, policy_params):\n",
    "        ''' 设置当前策略的参数\n",
    "        '''\n",
    "        self.model.load_state_dict(policy_params)\n",
    "        self.target_model.load_state_dict(policy_params)\n",
    "    \n",
    "    @torch.no_grad() # 不计算梯度，该装饰器效果等同于with torch.no_grad()：\n",
    "    def projection_distribution(self, next_states, rewards, dones):\n",
    "        ''' 用于计算下一时刻的分布\n",
    "        '''\n",
    "        # next_dist_target = self.target_model(next_states) # [batch_size, action_dim, n_atoms]\n",
    "        # next_q_values = (next_dist_target * self.support).sum(2) # [batch_size, action_dim]\n",
    "        # next_actions = torch.argmax(next_q_values, dim=1) # [batch_size]\n",
    "        # next_dist_target = next_dist_target[torch.arange(self.batch_size), next_actions.flatten()] # [batch_size, n_atoms]\n",
    "\n",
    "        # Double DQN\n",
    "        next_dist_curr = self.model(next_states) # [batch_size, action_dim, n_atoms]\n",
    "        next_q_values_curr = (next_dist_curr * self.support).sum(2) # [batch_size, action_dim]\n",
    "        next_actions_curr = torch.argmax(next_q_values_curr, dim=1) # [batch_size]\n",
    "        next_dist_target = self.target_model(next_states) # [batch_size, action_dim, n_atoms]\n",
    "        next_dist_target = next_dist_target.gather(1, next_actions_curr.unsqueeze(-1).unsqueeze(-1).expand(-1,-1, self.n_atoms)).squeeze(1) # [batch_size, n_atoms]\n",
    "    \n",
    "        # next_dist_target = next_dist_target[torch.arange(self.batch_size), next_actions_curr.flatten()] # [batch_size, n_atoms]\n",
    "\n",
    "        Tz = rewards + (1-dones) * self.gamma * self.support\n",
    "        Tz = Tz.clamp(min = self.v_min, max = self.v_max)\n",
    "        b = (Tz - self.v_min) / self.delta_z\n",
    "        l = b.floor().long()\n",
    "        u = b.ceil().long()\n",
    "        delta_m_l = (u + (l == u) - b) * next_dist_target  # (batch_size, n_atoms)\n",
    "        delta_m_u = (b - l) * next_dist_target # (batch_size, n_atoms)\n",
    "        self.proj_dist *= 0\n",
    "        self.proj_dist.view(-1).index_add_(0, (l + self.offset).view(-1), delta_m_l.view(-1))\n",
    "        self.proj_dist.view(-1).index_add_(0, (u + self.offset).view(-1), delta_m_u.view(-1))\n",
    "\n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
    "            return\n",
    "        # 从经验回放中随机采样一个批量的样本\n",
    "        (states, actions, rewards, next_states, dones), idxs, weights = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        # 将数据转换为tensor\n",
    "        states = torch.tensor(np.array(states), device = self.device, dtype=torch.float) # [B, state_dim]\n",
    "        actions = torch.tensor(actions, device=self.device,  dtype = torch.int64).unsqueeze(1)  #  [B, 1]\n",
    "        rewards = torch.tensor(rewards, device=self.device, dtype=torch.float).unsqueeze(1)   # [B, 1]\n",
    "        next_states = torch.tensor(np.array(next_states), device=self.device, dtype=torch.float) # [batchB_size, state_dim]\n",
    "        dones = torch.tensor(np.float32(dones), device=self.device).unsqueeze(1)  # [batch_size,1]\n",
    "        weights = torch.tensor(weights, device=self.device, dtype=torch.float).unsqueeze(1) # [B,1]\n",
    "        # 计算下一时刻的分布\n",
    "        self.projection_distribution(next_states, rewards, dones)\n",
    "        # 计算当前状态的分布\n",
    "        dist = self.model(states) # [batch_size, action_dim, n_atoms]\n",
    "        # dist = dist[torch.arange(self.batch_size), actions.flatten()]\n",
    "        dist = dist.gather(1, actions.unsqueeze(-1).expand(-1, -1, self.n_atoms)).squeeze(1) # [batch_size, n_atoms]\n",
    "        # dist = dist[torch.arange(self.cfg.batch_size), actions.squeeze(1).cpu().numpy()] # [batch_size, n_atoms]\n",
    "        # action_ = actions.unsqueeze(1).expand(self.batch_size, 1, self.n_atoms)\n",
    "        # dist = dist.gather(1, action_).squeeze(1) # [batch_size, n_atoms]\n",
    "        # dist.data.clamp_(0.01, 0.99) # 为了数值稳定，将概率值限制在[0.01, 0.99]之间\n",
    "        # print(self.proj_dist.shape, dist.shape)\n",
    "        loss = (-(self.proj_dist * dist.clamp(min=1e-5, max=1 - 1e-5).log()).sum(-1)).mean()\n",
    "        # print(proj_dist.grad_fn, dist.grad_fn)\n",
    "        loss = -(self.proj_dist * dist.clamp(min=1e-5, max=1 - 1e-5).log()).sum(-1) # [batch_size, n_atoms]\n",
    "        loss = (loss * weights).mean() # [batch_size, n_atoms]\n",
    "\n",
    "        td_errors = (dist * self.support).sum(1) - (self.proj_dist * self.support).sum(1)# 计算TD误差\n",
    "        priorities = td_errors.squeeze().cpu().detach().numpy() + 1e-5 # 计算TD误差\n",
    "        # 需要更新样本的优先度\n",
    "        self.memory.update_priorities(idxs, priorities) \n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        # clip防止梯度爆炸\n",
    "        # for param in self.model.parameters():  \n",
    "        #     param.grad.data.clamp_(-1, 1)\n",
    "        # torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)\n",
    "        self.optimizer.step() \n",
    "        self.update_cnt += 1\n",
    "        # 每隔一定步数更新目标网络的参数\n",
    "        # 软更新\n",
    "        for param, target_param in zip(self.model.parameters(), self.target_model.parameters()):\n",
    "            target_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data)\n",
    "\n",
    "        # if self.update_cnt % self.target_hard_update_freq == 0:\n",
    "        #     self.target_model.load_state_dict(self.model.state_dict())\n",
    "\n",
    "        self.model.reset_noise() # 重置当前网络的噪声\n",
    "        self.target_model.reset_noise() # 重置目标网络的噪声\n",
    "        return loss.item()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义可视化函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_curve(cfg: Config, frames: list, rewards : list, label:str = \"rewards\", title:str = None):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    if title is None:\n",
    "        title = f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\"\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(title)\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label=f\"{label}\")\n",
    "    plt.plot(frames, smooth(rewards), label=f\"{label}_smoothed\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg: Config):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    allow_types = ['int', 'float', 'str', 'bool', 'list', 'dict']\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        if v.__class__.__name__ not in allow_types:\n",
    "            continue\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "\n",
    "class EnvMgr:\n",
    "    def __init__(self, cfg: Config):\n",
    "        self.env = gym.make(cfg.env_id) # 创建环境\n",
    "        self.eval_env = gym.make(cfg.env_id)\n",
    "        print(f\"env id: {cfg.env_id}, state_dim: {self.state_dim}, action_dim: {self.action_dim}\")\n",
    "    @property\n",
    "    def action_dim(self):\n",
    "        return self.env.action_space.n # 动作空间的维度\n",
    "    @property\n",
    "    def state_dim(self):\n",
    "        return self.env.observation_space.shape[0]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义训练和测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def eval_policy(cfg: Config, policy: Policy, env):\n",
    "    ''' 测试\n",
    "    '''\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    for i_ep in range(cfg.online_eval_episode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            action = policy.predict_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "    \n",
    "    return np.mean(rewards)\n",
    "\n",
    "def train(cfg: Config, policy: Policy, env_mgr: EnvMgr):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    env = env_mgr.env\n",
    "    eval_env = env_mgr.eval_env\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    eval_rewards = []  # 记录所有回合的奖励\n",
    "    losses = []  # 记录所有回合的损失\n",
    "    best_policy_params = None  # 最佳策略\n",
    "    best_ep_reward = float('-inf') # 最佳回合的奖励\n",
    "\n",
    "    tot_step = 0\n",
    "    for i_ep in range(cfg.max_epsiode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            ep_step += 1\n",
    "            tot_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, terminated or truncated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            # 更新智能体，这里也可以改成每采样50步再更新50次\n",
    "            if tot_step%cfg.update_every == 0:\n",
    "                for _ in range(cfg.update_every):\n",
    "                    loss = policy.update()  \n",
    "                    if loss is not None:\n",
    "                        losses.append(loss)\n",
    "                if policy.update_cnt > 0 and policy.update_cnt % cfg.online_eval_freq == 0:\n",
    "                    eval_reward = eval_policy(cfg, policy, eval_env)\n",
    "                    eval_rewards.append(eval_reward)\n",
    "                    if eval_reward >= best_ep_reward:\n",
    "                        print(f\"找到新的最优策略，回合：{i_ep+1}，模型步数：{policy.update_cnt}，测试奖励：{eval_reward:.2f}\")\n",
    "                        best_ep_reward = eval_reward\n",
    "                        best_policy_params = policy.get_policy_params()\n",
    "            # policy.update() \n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.max_epsiode}，奖励：{ep_reward:.2f}，Epislon：{policy.exploration_mgr.epsilon:.3f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'eval_rewards':eval_rewards, 'losses':losses,'best_policy_params':best_policy_params}\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env id: CartPole-v1, state_dim: 4, action_dim: 2\n",
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t     RainbowDQN     \t   <class 'str'>    \n",
      "       env_id       \t    CartPole-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "    max_epsiode     \t        200         \t   <class 'int'>    \n",
      "      max_step      \t        200         \t   <class 'int'>    \n",
      "online_eval_episode \t         10         \t   <class 'int'>    \n",
      "  online_eval_freq  \t        2000        \t   <class 'int'>    \n",
      "       gamma        \t        0.99        \t  <class 'float'>   \n",
      "   epsilon_start    \t        0.95        \t  <class 'float'>   \n",
      "    epsilon_end     \t        0.01        \t  <class 'float'>   \n",
      "   epsilon_decay    \t       0.0004       \t  <class 'float'>   \n",
      "    buffer_size     \t       100000       \t   <class 'int'>    \n",
      "   buffer_n_step    \t         3          \t   <class 'int'>    \n",
      "     per_alpha      \t        0.6         \t  <class 'float'>   \n",
      "    per_epsilon     \t       1e-05        \t  <class 'float'>   \n",
      "      per_beta      \t        0.4         \t  <class 'float'>   \n",
      "per_beta_increment_per_sampling\t       0.0001       \t  <class 'float'>   \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "     batch_size     \t        256         \t   <class 'int'>    \n",
      "   target_update    \t        100         \t   <class 'int'>    \n",
      "    update_every    \t         50         \t   <class 'int'>    \n",
      "         lr         \t       0.0001       \t  <class 'float'>   \n",
      "        tau         \t       0.005        \t  <class 'float'>   \n",
      "      n_atoms       \t         51         \t   <class 'int'>    \n",
      "       v_min        \t        -100        \t   <class 'int'>    \n",
      "       v_max        \t        100         \t   <class 'int'>    \n",
      "       device       \t        cuda        \t   <class 'str'>    \n",
      "================================================================================\n",
      "回合：10/200，奖励：17.00，Epislon：0.847\n",
      "回合：20/200，奖励：11.00，Epislon：0.784\n",
      "回合：30/200，奖励：36.00，Epislon：0.700\n",
      "回合：40/200，奖励：19.00，Epislon：0.636\n",
      "回合：50/200，奖励：15.00，Epislon：0.530\n",
      "回合：60/200，奖励：99.00，Epislon：0.446\n",
      "找到新的最优策略，回合：62，模型步数：2000，测试奖励：200.00\n",
      "回合：70/200，奖励：151.00，Epislon：0.263\n",
      "回合：80/200，奖励：200.00，Epislon：0.124\n",
      "找到新的最优策略，回合：84，模型步数：6000，测试奖励：200.00\n",
      "回合：90/200，奖励：187.00，Epislon：0.061\n",
      "找到新的最优策略，回合：94，模型步数：8000，测试奖励：200.00\n",
      "回合：100/200，奖励：200.00，Epislon：0.033\n",
      "找到新的最优策略，回合：104，模型步数：10000，测试奖励：200.00\n",
      "回合：110/200，奖励：200.00，Epislon：0.020\n",
      "找到新的最优策略，回合：114，模型步数：12000，测试奖励：200.00\n",
      "回合：120/200，奖励：200.00，Epislon：0.015\n",
      "找到新的最优策略，回合：124，模型步数：14000，测试奖励：200.00\n",
      "回合：130/200，奖励：200.00，Epislon：0.012\n",
      "找到新的最优策略，回合：135，模型步数：16000，测试奖励：200.00\n",
      "回合：140/200，奖励：200.00，Epislon：0.011\n",
      "找到新的最优策略，回合：145，模型步数：18000，测试奖励：200.00\n",
      "回合：150/200，奖励：200.00，Epislon：0.010\n",
      "找到新的最优策略，回合：155，模型步数：20000，测试奖励：200.00\n",
      "回合：160/200，奖励：200.00，Epislon：0.010\n",
      "找到新的最优策略，回合：165，模型步数：22000，测试奖励：200.00\n",
      "回合：170/200，奖励：200.00，Epislon：0.010\n",
      "找到新的最优策略，回合：175，模型步数：24000，测试奖励：200.00\n",
      "回合：180/200，奖励：200.00，Epislon：0.010\n",
      "找到新的最优策略，回合：185，模型步数：26000，测试奖励：200.00\n",
      "回合：190/200，奖励：200.00，Epislon：0.010\n",
      "找到新的最优策略，回合：195，模型步数：28000，测试奖励：200.00\n",
      "回合：200/200，奖励：200.00，Epislon：0.010\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 获取参数\n",
    "cfg = Config() \n",
    "env_mgr = EnvMgr(cfg) # 创建环境\n",
    "policy = Policy(cfg, env_mgr.state_dim, env_mgr.action_dim) # 创建策略\n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg, policy, env_mgr) # 训练\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_curve(cfg, range(len(res['rewards'])), res['rewards'], label = \"rewards\", title = f\"{cfg.mode}ing rewards on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "plot_curve(cfg, range(len(res['losses'])), res['losses'], label = \"losses\", title = f\"{cfg.mode}ing losses on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "plot_curve(cfg, range(len(res['eval_rewards'])), res['eval_rewards'], label = \"eval_rewards\", title = f\"online eval reward on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "joyrl-book",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
